﻿using Microsoft.EntityFrameworkCore.Metadata.Internal;
using NPOI.SS.Formula.Functions;
using System;

namespace ConsoleApp.Utils
{
    public static class CommonUtil
    {
        /// <summary>
        /// 万能基础数据类型转换器
        /// </summary>
        /// <typeparam name="T">目标基础数据类型</typeparam>
        /// <param name="obj">待转换数据</param>
        /// <returns>转换后的数据，类型为 T</returns>
        public static T DataConverter<T>(Object obj)
        {
            try
            {
                // 如果传入对象是 null 或 DBNull，并且目标类型是 string，返回空字符串
                if ((obj == null || obj == DBNull.Value) && (typeof(T) == typeof(string)))
                {
                    return (T)Convert.ChangeType("", typeof(T));
                }
                // 如果传入对象已经是目标类型，直接返回
                if (obj is T)
                {
                    return (T)obj;
                }
                // 处理 Nullable<T> 类型
                if (typeof(T).IsGenericType)
                {
                    Type genericTypeDefinition = typeof(T).GetGenericTypeDefinition();
                    if (genericTypeDefinition == typeof(Nullable<>))
                    {
                        return (T)Convert.ChangeType(obj, Nullable.GetUnderlyingType(typeof(T)));
                    }
                }
                // 进行类型转换
                return (T)Convert.ChangeType(obj, typeof(T));
            }
            catch (InvalidCastException ex)
            {
                // 如果发生转换异常，尝试返回原对象的强制转换
                return (T)obj;
            }
            catch (Exception ex)
            {
                // 其他异常直抛
                throw;
            }
        }
        /// <summary>
        /// 范围判断函数，检查给定的值是否在指定的最小值和最大值之间。
        /// 例如，可以用来判断当前日期是否在开始日期和结束日期之间。
        /// 该方法适用于任何实现了 IComparable 接口的类型，比如 int、double、DateTime 等等。
        /// </summary>
        /// <typeparam name="T">实现了 IComparable 接口的泛型类型参数</typeparam>
        /// <param name="value">要比较的值</param>
        /// <param name="min">范围的最小值</param>
        /// <param name="max">范围的最大值</param>
        /// <returns>如果 value 在 min 和 max 之间，则返回 true；否则返回 false</returns>
        public static bool Between<T>(T value, T min, T max) where T : IComparable<T>
        {
            // 使用 CompareTo 方法比较 value、min 和 max 的大小关系
            // value 必须大于或等于 min，并且小于或等于 max
            // 这里可以根据实际业务场景需求调整
            return value.CompareTo(min) >= 0 && value.CompareTo(max) <= 0;
        }

        public static void test()
        {
            #region 测试DataConverter
            // 将 null 转换为目标类型，默认为该类型的默认值
            var result = CommonUtil.DataConverter<T>(null);

            // 从字典中获取一个值并转换
            var result2 = CommonUtil.DataConverter<T>("1");

            // 将字符串 "True" 转换为布尔类型
            var result3 = CommonUtil.DataConverter<bool>("True");

            // 将字符串 "123" 转换为整型
            var result4 = CommonUtil.DataConverter<int>("123");

            // 尝试将无效字符串 "test" 转换为整型，捕获异常
            var result5 = CommonUtil.DataConverter<int>("test");

            // 将整型 123 转换为字符串
            var result6 = CommonUtil.DataConverter<string>(123);

            // 将 null 转换为字符串，返回空字符串
            var result7 = CommonUtil.DataConverter<string>(null);

            #endregion

            #region 测试Between
            // 测试数字
            int num = 5;
            if (CommonUtil.Between(num, 1, 10))
            {
                Console.WriteLine($"{num} 在 1 和 10 之间。");
            }
            else
            {
                Console.WriteLine($"{num} 不在 1 和 10 之间。");
            }

            // 测试日期
            DateTime startDate = new DateTime(2024, 9, 25);
            DateTime endDate = new DateTime(2024, 10, 25);
            DateTime currentDate = DateTime.Now;

            if (CommonUtil.Between(currentDate, startDate, endDate))
            {
                Console.WriteLine($"当前日期在 {startDate.ToShortDateString()} 和 {endDate.ToShortDateString()} 之间。");
            }
            else
            {
                Console.WriteLine($"当前日期不在 {startDate.ToShortDateString()} 和 {endDate.ToShortDateString()} 之间。");
            }
            #endregion
        }
    }
}